#include <iostream>
#include <vector>
#include <string>
#include <type_traits>
#include <algorithm>
#include <cmath>
#include <cstdlib>

namespace cpp23 {

// 一个使用[[unused]]属性的函数
void example_with_unused_attribute([[maybe_unused]] int unused_param) {
    // 参数在函数中未使用，但不会产生警告
}

// 假设以下为C++23的扩展属性示例（目前大多数编译器尚未完全支持）
// 这些只是示例，展示扩展属性的语法和潜在用途

// [[assume(expr)]] 属性示例 - 告诉编译器可以假设某个条件为真
void optimize_with_assume(int* array, size_t size) {
    [[assume(size > 0)]]; // 假设size始终大于0
    
    // 编译器可能会利用这个假设进行优化
    for (size_t i = 0; i < size; ++i) {
        array[i] = i;
    }
}

// [[expect(expr, probability)]] 属性示例 - 提示编译器某个条件的可能性
int binary_search(const std::vector<int>& sorted_data, int target) {
    int low = 0, high = sorted_data.size() - 1;
    
    while (low <= high) {
        int mid = low + (high - low) / 2;
        
        // 假设通常情况下不会立即找到目标
        // [[expect(sorted_data[mid] != target, 0.9)]]
        if (sorted_data[mid] == target) {
            return mid;
        } else if (sorted_data[mid] < target) {
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    
    return -1;
}

// [[nodiscard("reason")]] 带原因的属性示例 - C++20引入，C++23扩展
[[nodiscard("数据需要被处理，否则会导致内存泄漏")]]
std::vector<int> load_important_data() {
    return std::vector<int>{1, 2, 3, 4, 5};
}

// [[deprecated("reason")]] 带原因的属性，C++14引入，在C++23中得到扩展
[[deprecated("此函数在后续版本中将被移除，请使用new_function代替")]]
void old_function() {
    std::cout << "这是一个过时的函数\n";
}

// 一个使用多个属性的函数示例
[[nodiscard]]
// 注意：GCC特定的属性语法，某些版本可能需要不同的写法
inline int optimized_calculation(int x, int y) {
    return x * y + (x + y);
}

// 注意：以下代码展示了C++23计划中的扩展属性功能
// 当前很多编译器可能尚未实现这些功能

// 使用[[assume(expr)]]属性
int sqrt_optimized(int x) {
    [[assume(x >= 0)]]; // 告诉编译器x总是非负的
    return static_cast<int>(std::sqrt(x));
}

// 使用[[likely]]和[[unlikely]]属性增强
int process_value(int x) {
    if (x > 100) [[likely]] {
        // 这条分支被提示为更可能执行
        return x * 2;
    } else if (x < 0) [[unlikely]] {
        // 这条分支被提示为不太可能执行
        return 0;
    } else {
        return x;
    }
}

// 展示[[consteval]]属性
[[consteval]] int compile_time_calculation(int x, int y) {
    return x * y + 42;
}

// 展示[[noreturn]]属性
[[noreturn]] void fatal_error(const std::string& message) {
    std::cerr << "致命错误: " << message << std::endl;
    std::terminate();
}

// 展示命名空间属性
namespace [[deprecated("使用new_features命名空间代替")]] old_features {
    void legacy_function() {
        std::cout << "这是一个过时的函数\n";
    }
}

namespace new_features {
    void modern_function() {
        std::cout << "这是一个现代的函数\n";
    }
}

// 展示扩展点属性示例
// 注意：这是C++23中计划的特性，目前编译器可能不支持
// [[extension::vendor::attribute]]
void vendor_specific_function() {
    // 假设使用了供应商特定的属性
    std::cout << "这个函数使用了供应商特定的属性\n";
}

// 展示类和函数的多个属性组合
class [[nodiscard("不使用返回值将造成资源泄露")]] ResourceHandle {
public:
    ResourceHandle() { std::cout << "资源已分配\n"; }
    ~ResourceHandle() { std::cout << "资源已释放\n"; }
    
    [[nodiscard]] 
    bool is_valid() const { return true; }
    
    [[deprecated("使用process_data()代替")]]
    void process() { std::cout << "处理资源\n"; }
    
    void process_data() { std::cout << "使用新方法处理资源\n"; }
};

// 使用[[fallthrough]]属性
void process_command(int cmd) {
    switch (cmd) {
        case 1:
            std::cout << "执行命令1\n";
            [[fallthrough]]; // 故意继续执行下一个case
        case 2:
            std::cout << "执行命令2\n";
            break;
        case 3:
            std::cout << "执行命令3\n";
            break;
        default:
            std::cout << "未知命令\n";
    }
}

// 使用[[maybe_unused]]属性
void debug_function([[maybe_unused]] const std::string& info) {
#ifdef DEBUG
    std::cout << "调试信息: " << info << std::endl;
#endif
}

// 展示C++23中计划的契约属性（注意：这是提案中的特性，目前编译器可能不支持）
int divide(int a, int b) {
    // [[expects: b != 0]] - 这是C++23中计划的契约特性语法
    if (b == 0) {
        throw std::invalid_argument("除数不能为零");
    }
    return a / b;
}

// C++23引入了许多新的属性(Attributes)来增强代码表达能力和编译器优化

// [[assume(expr)]] 属性 - 提示编译器某个表达式总是为真
// 注意：此示例是概念性的，因为很多编译器尚未完全支持
void demonstrate_assume(int x, int y) {
    // 告诉编译器我们假设x总是大于0，可能启用一些优化
    [[assume(x > 0)]];
    
    if (x <= 0) {
        // 编译器可能优化掉这个分支，因为我们已经假设x > 0
        std::cout << "这个分支可能不会被执行" << std::endl;
    }
    
    // 假设y在0到100之间
    [[assume(y >= 0 && y <= 100)]];
    
    // 编译器可以利用这个假设来优化下面的循环
    for (int i = 0; i < y; ++i) {
        // 可能会进行循环展开或其他优化
    }
}

// [[likelihood(likely|unlikely)]] 属性 - 提示条件分支的可能性
int optimize_branches(int value) {
    if (value > 100) [[unlikely]] { // 提示编译器这个分支不太可能执行
        return value * 2;
    } else [[likely]] { // 提示编译器这个分支更可能执行
        return value;
    }
}

// 添加allocate_resource函数的定义
[[nodiscard("忽略返回值会导致资源泄漏")]]
int allocate_resource() {
    std::cout << "资源已分配\n";
    return 42; // 返回资源句柄
}

// 前向声明（在namespace cpp23中）
int compute_factorial(int n);
int optimized_binary_search(const std::vector<int>& sorted_array, int target);
void process_data(const std::vector<int>& data);
void compact_function();
void fast_function();

// 演示不同的属性
void demonstrate_extended_attributes() {
    std::cout << "C++23 扩展属性演示\n";
    std::cout << "=====================\n\n";

    std::cout << "1. [[assume]] 属性:\n";
    std::cout << "   用于告诉编译器可以假设某个条件为真，启用更多优化。\n";
    std::cout << "   示例: [[assume(x > 0)]] 告诉编译器x总是大于0\n\n";

    std::cout << "2. [[likelihood]] 属性:\n";
    std::cout << "   用于提示条件分支的可能性。\n";
    std::cout << "   处理示例值10的结果: " << process_value(10) << "\n\n";

    std::cout << "3. [[noreturn]] 属性:\n";
    std::cout << "   表明函数永远不会正常返回。\n";
    std::cout << "   例如: fatal_error()函数\n\n";

    std::cout << "4. 增强的[[nodiscard]]:\n";
    std::cout << "   可以添加必须使用返回值的理由。\n";
    // 以下行可能会产生编译警告，因为我们忽略了标记为nodiscard的返回值
    // allocate_resource();
    int resource = allocate_resource(); // 正确使用
    std::cout << "   已分配资源: " << resource << "\n\n";

    std::cout << "5. [[deprecated]] 属性:\n";
    std::cout << "   标记已过时的功能。\n";
    // 下一行会产生编译警告
    // legacy_function();
    std::cout << "   (legacy_function已标记为过时)\n\n";

    std::cout << "6. [[fallthrough]] 属性:\n";
    std::cout << "   表明switch语句故意不使用break：\n";
    process_command(1);
    std::cout << "\n";

    std::cout << "7. [[maybe_unused]] 属性:\n";
    std::cout << "   防止对未使用的变量发出警告:\n";
    debug_function("测试信息");
    std::cout << "[[maybe_unused]]防止未使用参数的警告\n\n";

    std::cout << "8. [[likely]] 和 [[unlikely]] 属性:\n";
    std::cout << "   优化分支预测的例子:\n";
    std::cout << "   optimize_branches(1) = " << optimize_branches(1) << "\n";
    
    std::cout << "9. 其他C++23扩展属性示例:\n";
    
    // 演示[[assume]]属性的阶乘计算
    std::cout << "   - 使用[[assume(expr)]]优化的阶乘: " << compute_factorial(5) << "\n";
    
    // 演示优化的二分查找
    std::vector<int> sorted_data = {1, 3, 5, 7, 9, 11, 13, 15};
    int index = optimized_binary_search(sorted_data, 7);
    std::cout << "   - 优化的二分查找找到7的索引: " << index << "\n";
    
    // 演示assert属性
    try {
        process_data({10, 20, 30});
        // 以下代码在支持的编译器上可能会触发断言
        // process_data({});
    } catch (const std::exception& e) {
        std::cout << "   - 断言失败: " << e.what() << "\n";
    }
    
    // 演示优化属性
    compact_function();
    fast_function();
    
    std::cout << "\n注意：C++23扩展属性中的许多特性仍处于实验阶段，许多编译器可能尚未完全支持。\n";
    std::cout << "代码展示了这些特性的语法和用途，即使当前编译器可能尚未实现这些功能。\n";
}

// C++23引入了几种新的标准属性
// 注意：以下函数已在文件的其他地方定义，这里只是声明或注释说明

// 使用[[deprecated]]属性的新增选项
[[deprecated("请使用new_api()替代，将在下一版本移除")]]
void old_api() {
    std::cout << "调用旧API\n";
}

void new_api() {
    std::cout << "调用新API\n";
}

// C++23: [[no_unique_address]] - 优化空类存储
struct Empty {};

struct OptimizedStorage {
    int data;
    [[no_unique_address]] Empty e; // 可能不占用额外空间
};

// C++23新属性: [[carries_dependency]]
// 用于原子操作中，表示依赖关系传递
template <typename T>
[[carries_dependency]] T forward_dependency(T* p) {
    return *p;
}

// C++23: [[reproducible]] - 指示编译器使用确定性算法
[[reproducible]] int deterministic_calculation(int x) {
    // 使用确定性算法，结果在不同编译中保持不变
    return x * 42;
}

// C++23: [[unsequenced]] - 指示可以乱序执行的代码块
void parallel_operations(std::vector<int>& data) {
    [[unsequenced]] {
        for (size_t i = 0; i < data.size(); ++i) {
            data[i] = data[i] * 2;
        }
    }
}

// 演示在更多上下文中使用属性
struct [[nodiscard]] ImportantResult {
    int value;
};

// 在类中使用属性
class DataProcessor {
    [[no_unique_address]] Empty empty_member;
    
    // 在参数上使用属性
    void process([[maybe_unused]] int priority, 
                 [[maybe_unused]] const std::string& source) {
        // 在局部变量上使用属性
        [[maybe_unused]] int temp = 0;
    }

public:
    // 在返回值上使用属性
    [[nodiscard]] ImportantResult get_result() {
        return {42};
    }
};

} // namespace cpp23

// 使用[[assume(expr)]]属性
// 该属性告诉编译器可以假设表达式为真，从而可能进行更多优化
namespace cpp23 {
int compute_factorial(int n) {
  [[assume(n >= 0)]]; // 假设n非负
  if (n <= 1) return 1;
  return n * compute_factorial(n - 1);
}

// 使用[[assume]]属性的函数
int optimized_binary_search(const std::vector<int>& sorted_array, int target) {
  int left = 0;
  int right = static_cast<int>(sorted_array.size()) - 1;
  
  [[assume(right >= left)]]; // 假设输入有效
  
  while (left <= right) {
    int mid = left + (right - left) / 2;
    
    if (sorted_array[mid] == target) {
      return mid; // 找到目标
    }
    
    if (sorted_array[mid] < target) {
      left = mid + 1;
    } else {
      right = mid - 1;
    }
    
    [[assume(right >= -1)]]; // 假设循环不变量
    [[assume(left <= static_cast<int>(sorted_array.size()))]]; // 假设循环不变量
  }
  
  return -1; // 未找到目标
}

// 使用[[assert: expr]]属性
// 注意：GCC 13不支持contracts，使用标准assert代替
void process_data(const std::vector<int>& data) {
  // [[assert: data.size() > 0]]; // 运行时断言数据不为空（GCC 13不支持）
  if (data.size() == 0) {
    throw std::runtime_error("数据不能为空");
  }
  
  // 处理数据
  std::cout << "处理 " << data.size() << " 个元素...\n";
}

// 使用[[optimize_for_size]]属性
[[optimize_for_size]] // 优化代码大小而非速度
void compact_function() {
  std::cout << "此函数已针对代码大小进行优化\n";
  // 这里是一些应该保持小巧的代码
}

// 使用[[optimize_for_speed]]属性
[[optimize_for_speed]] // 优化速度而非代码大小
void fast_function() {
  std::cout << "此函数已针对速度进行优化\n";
  // 这里是一些应该尽可能快的代码
}

} // namespace cpp23 